PrepareLevel8:
	lea	StartLevel8PlatformData(pc),a0
	bra.s	PrepareLevel4WithDataAlreadySet

PrepareLevel7:
	lea	StartLevel7PlatformData(pc),a0
	bra.s	PrepareLevel4WithDataAlreadySet

PrepareLevel6:
	lea	StartLevel6PlatformData(pc),a0
	bra.s	PrepareLevel4WithDataAlreadySet

PrepareLevel5:
	lea	StartLevel5PlatformData(pc),a0
	bra.s	PrepareLevel4WithDataAlreadySet

PrepareLevel4:
	;; for this whole level a0 will be set to the level platform data
	lea	StartLevel4PlatformData(pc),a0

PrepareLevel4WithDataAlreadySet:	
	;; split prepare common into two parts
	;; since want score above road for twoplayer
	bsr	PrepareLevelCommonPart1

	btst	#TwoPlayerFlag,Flags
	bne.s	PrepareLevel4TwoPlayer

PrepareLevel4OnePlayer:	
	lea	StartSpriteLevel4Initial(pc),a5
	bsr	SpriteLoad

	lea	RileySprite,a5
	moveq	#0,d3
	move.l	#$47000003,d7
	bsr	LoadPlatformData

	moveq	#0,d0
	move.w	(a5),d0
	lsl.l	#8,d0
	move.l	d0,Level4RileyPositionY

	bra.s	PrepareLevel4Final
	
PrepareLevel4TwoPlayer:	
	lea	StartSpriteLevel4TwoPlayerInitial(pc),a5
	bsr	SpriteLoad

	lea	RileySprite,a5
	moveq	#0,d3
	move.l	#$40000003,d7
	bsr	LoadPlatformData

	moveq	#0,d0
	move.w	(a5),d0
	lsl.l	#8,d0
	move.l	d0,Level4RileyPositionY

	lea	Riley2Sprite,a5
	move.w	#$2000,d3
	move.l	#$47000003,d7
	bsr	LoadPlatformData
	
	moveq	#0,d0
	move.w	(a5),d0
	lsl.l	#8,d0
	move.l	d0,Level4Riley2PositionY

PrepareLevel4Final:	

	;; position of twoplayer scoreboard
	;; VRAM C784
	move.l	#$47840003,d7
	bsr	PrepareLevelCommonPart2

	;; clear jump flag
	clr.b	Level4Flags
	clr.b	Level4Flags2

	lea	Level4Animate(pc),a5
	move.l	a5,VintAnimate

	bsr	Level4RefreshLetters
	bsr	FadeIn
	
Level4Loop:	
	bsr	WaitForVint
	;; NOTE: no demo for the final level
	;; check for sprite collision
	move.w   (a4),d0
	andi.b   #$0020,d0
	beq      Level4MoveRiley1
	;; there is a sprite collision
	;; check for player 1 collision
	;; see if letter is $00 (means it it in the bin)
	cmpi.b   #$20,LetterSprite+5
	beq.s    Level4PossibleBinCollision
	;; see if letter already disabled (set tile to $20)
	tst.b    LetterSprite+5
	beq.s    Level4Player2Collision
	;; collision check
	lea	RileySprite,a5
	lea	LetterSprite,a6
	bsr	CheckSpriteCollision
	bne.s	Level4Player2Collision
	;; it is a letter collision
	;; disable letter sprite by setting it to clear tile
	;; this will indicate the letter was picked up
	move.b  #$20,LetterSprite+5
	bra.s   Level4Player2Collision
Level4PossibleBinCollision:
	;; collision check
	lea	RileySprite,a5
	lea	BinSprite,a6
	bsr	CheckSpriteCollision
	bne.s	Level4Player2Collision
	;; is a bin collision
	;; now update the score
	lea     EndScoreAscii,a5
        move.l  #$40900003,d0
	move.w  #(EndScoreAscii-StartScoreAscii-1),d1
	clr.w	d2
	move.b  WordIndex,d2
	;; make high priority (so score will go above other things)
	move.w  #$8000,d4
	bsr	UpdateAndDisplayScoreAndWord

	;; get next character
	clr.w	d0
	move.b  WordIndex,d0
	clr.w	d1
	move.b  WordIndex2,d1
	bsr	GetNextLetter
	move.b	d0,WordIndex

	clr.b	LetterSprite+5

Level4Player2Collision:	
	;; check for player 2 collision
	btst	#TwoPlayerFlag,Flags
	beq.s	Level4CheckRefreshLetters
	;; see if letter is $00 (means it was picked up)
	cmpi.b   #$20,Letter2Sprite+5
	beq.s    Level4PossibleBin2Collision
	;; see if letter already disabled (set tile to $20)
	tst.b    Letter2Sprite+5
	beq.s   Level4CheckRefreshLetters
	;; collision check
	lea	Riley2Sprite,a5
	lea	Letter2Sprite,a6
	bsr	CheckSpriteCollision
	bne.s	Level4CheckRefreshLetters
	;; is a letter collision
	;; disable letter sprite by setting it to clear tile
	;; this will indicate the letter was picked up
	move.b  #$20,Letter2Sprite+5
	bra.s   Level4CheckRefreshLetters
Level4PossibleBin2Collision:
	;; collision check
	lea	Riley2Sprite,a5
	lea	Bin2Sprite,a6
	bsr	CheckSpriteCollision
	bne.s	Level4CheckRefreshLetters
	;; is a bin collision
	;; now update the score
	lea     EndScoreAscii2,a5
	move.l	#$47900003,d0
	move.w  #(EndScoreAscii2-StartScoreAscii2-1),d1
	clr.w	d2
	move.b  WordIndex2,d2
	;; make high priority (so score will go above other things)
	move.w  #$A000,d4
	bsr	UpdateAndDisplayScoreAndWord

	;; get next character
	clr.w	d0
	move.b  WordIndex2,d0
	clr.w	d1
	move.b  WordIndex,d1
	bsr	GetNextLetter
	move.b	d0,WordIndex2

	clr.b	Letter2Sprite+5
	
Level4CheckRefreshLetters:	
	bclr	#RefreshLettersWordFlag,WordFlags
	beq.s	Level4CheckNewLevel
	bsr	Level4RefreshLetters
	
Level4CheckNewLevel:	
	;; check if need to go to next level
	bclr	#NewLevelFlag,WordFlags
	beq.s	Level4MoveRiley1
	bsr	LevelTransition
	;; level data contains index of next level
	clr.w	d0
	move.b	PlatformOffsetNextLevel(a0),d0
	bsr	LevelSelectJump
	
Level4MoveRiley1:	
	lea	RileySprite,a5
	lea     Level4RileyPositionY,a6
	;; Port1Hold and Port1Press as a word
        move.w  Port1Hold,d0
	bsr.s	Level4CheckRileyChange
Level4MoveRiley2:	
	lea	Riley2Sprite,a5
	lea     Level4Riley2PositionY,a6
	;; Port1Hold and Port1Press as a word
        move.w  Port2Hold,d0
	bsr.s	Level4CheckRileyChange
EndLevel4Loop:	
	bra     Level4Loop


Level4Animate:
	movem.l	d0-d3/a5-a6,-(a7)

	lea	RileySprite,a5
	lea     Level4RileyPositionY,a6
	;; Port1Hold and Port1Press as a word
	move.w	Port1Hold,d3
	bsr.s	Level4MoveRiley

	lea	Riley2Sprite,a5
	lea     Level4Riley2PositionY,a6
	;; Port2Hold and Port2Press as a word
	move.w	Port2Hold,d3
	bsr.s	Level4MoveRiley

	movem.l	(a7)+,d0-d3/a5-a6
	rts

	;; subroutines for level 4

	
	;; used sonic physics guide on sonic retro as an example

	;; want to be able to jump 2 * height and somewhere around one second
	;; tried earth's gravity originally
	;; it was way too slow (when comparing to sonic and such)

	;; so wanted 2/3 second jump that was 2 times riley height
	;; since go up and down, time is 20 frames (NTSC)
	;; v = 2 * s / t
	;; v = 2 * 48 pixels / 20 frames
	;; a = v / t
	;; a = 51/256 pixels/frame/frame
	;; v = 1020/256 pixels/frame

	;; Level4CheckRileyChange only checks for a new jump
	;; Level4MoveRiley only handles a jump already in progress
	
	;; a5 has RileySprite
	;; a6 has movement data block
	;; d0 has port
Level4CheckRileyChange:	
	;; check if already jumping
	btst	#JumpLevel4Flag,6(a6)
	bne.s	Level4CheckRileyChangeDone

	;; look for a new jump from a button press
	andi.b	#(btnA|btnB|btnC),d0
	beq.s	Level4CheckRileyChangeDone

	;; detected a new jump, set our initial speed
	;; set RileySpeedY or Riley2SpeedY
	move.w	#JumpVelocity,4(a6)
	;; indicate in jump state
	bset	#JumpLevel4Flag,6(a6)

Level4CheckRileyChangeDone:	
	rts



	
	;; a5 has RileySprite
	;; a6 has movement data block
	;; d3 has port
Level4MoveRiley:
	btst	#JumpLevel4Flag,6(a6)
	beq.s	Level4MoveRileyJumpDone
	
	;; get RileyPositionY or Riley2PositionY
	move.l	(a6),d0
	;; get RileySpeedY or Riley2SpeedY
	move.w	4(a6),d1

	;; slow down the jump speed linearly (constant acceleration)
	subi.w	#JumpGravity,d1

	;; see if care if jump button(s) still pressed
	;; this allows variable height jumps
	cmpi.w	#JumpVelocityReduced,d1
	ble.s	Level4MoveRileyStillJumping

	;; check if jump button(s) still pressed
	move.w	d3,d2
	andi.w	#((btnA<<8)|(btnB<<8)|(btnC<<8)),d2
	bne.s	Level4MoveRileyStillJumping

	;; restrict the jumping speed to reduce jump height based on when
	;; jump button was released
	move.w	#JumpVelocityReduced,d1
	
Level4MoveRileyStillJumping:	
	;; actually perform the jump movement
	ext.l	d1
	sub.l	d1,d0

	;; save position/speed
	movem.l	d0-d1,-(a7)
	
	;; store new y position in d1
	lsr.l	#8,d0

	;; check top if moving up, check bottom if moving down
	tst	d1
	bmi.s	Level4MoveRileyStillJumpingCheckBottom

	move.w	d0,d1
	;; use current x position in d0
	move.w	6(a5),d0
	bsr	DetermineRileySpriteTopSolid

	;; restore position/speed (does not change ccr)
	movem.l	(a7)+,d0-d1

	beq.s	Level4MoveRileyJumpSave

	;; found ground, stop jumping and start fall
	andi.l	#$FFFFF800,d0
	addi.l	#$00000800,d0
	clr.w	d1

	bra.s	Level4MoveRileyJumpSave

Level4MoveRileyStillJumpingCheckBottom:	
	move.w	d0,d1
	;; use current x position in d0
	move.w	6(a5),d0
	bsr	DetermineRileySpriteBottomSolid

	;; restore position/speed (does not change ccr)
	movem.l	(a7)+,d0-d1

	beq.s	Level4MoveRileyJumpSave

	;; found ground, stop jumping
	andi.l	#$FFFFF800,d0
	clr.w	d1
	bclr	#JumpLevel4Flag,6(a6)
	
Level4MoveRileyJumpSave:
	;; set RileyPositionY or Riley2PositionY
	move.l	d0,(a6)
	;; set RileySpeedY or Riley2SpeedY
	move.w	d1,4(a6)
	;; update riley y position
	lsr.l	#8,d0
	move.w	d0,(a5)
	
Level4MoveRileyJumpDone:	

	;; if past end of words for this level
	;; do not allow moving left/right
	;; this only allows falling from existing jump during fade out
	cmpi.b	#LevelWords,WordsForLevel
	bge.s	Level4MoveRileyDone

	move.w	6(a5),d2
	moveq	#$07,d4

	btst	#(bitLeft+8),d3
	bne.s	Level4MoveRileyLeft

	btst	#(bitRight+8),d3
	bne.s	Level4MoveRileyRight

	bra.s	Level4MoveRileyDone

Level4MoveRileyLeft:
	subq.w	#1,d2
	bset	 #3,4(a5)

	;; check if moved into wall
	move.w	d2,d0
	move.w	(a5),d1
	bsr	DetermineRileySpriteLeftSolid
	bne.s	Level4MoveRileyDone

	bra.s	 Level4MoveRileyAnimateStride

Level4MoveRileyRight:
	bclr	#3,4(a5)

	;; check if moved into wall
	move.w	d2,d0
	move.w	(a5),d1
	bsr	DetermineRileySpriteRightSolid
	bne.s	Level4MoveRileyDone

	addq.w	#1,d2

Level4MoveRileyAnimateStride:
	move.w	d2,6(a5)
	btst	#JumpLevel4Flag,6(a6)
	bne.s	Level4MoveRileyCheckForFall
	and.b   VintCounter+1,d4
	bne.s	Level4MoveRileyCheckForFall
	bsr	NextStrideFrame

Level4MoveRileyCheckForFall:
	btst	#JumpLevel4Flag,6(a6)
	bne.s	Level4MoveRileyDone

	;; use current x position in d0
	move.w	6(a5),d0
	;; use current y position in d1
	move.w	(a5),d1
	bsr.s	DetermineRileySpriteBottomSolid
	bne.s	Level4MoveRileyDone

	;; falling (set jump to true and vertical speed to 0)
	clr.w	4(a6)
	bset	#JumpLevel4Flag,6(a6)
	
	;; animate walking (makes descending staircases better)
	;; only animate if not already animated
	and.b   VintCounter+1,d4
	beq.s	Level4MoveRileyDone
	bsr	NextStrideFrame
	
Level4MoveRileyDone:	

	rts


	;; a0.l level data
	;; a5.l sprites for player
	;; d0.w is new riley x spot
	;; d1.w is new riley y spot
DetermineRileySpriteTopSolid:	
	movem.w	d0-d3,-(a7)
	;; invert side of playing field and account for Riley's height
	move.w	#14,d2
	bra.s	DetermineRileySpriteTopBottomSolid

	;; a0.l level data
	;; a5.l sprites for player
	;; d0.w is new riley x spot
	;; d1.w is new riley y spot
DetermineRileySpriteBottomSolid:	
	movem.w	d0-d3,-(a7)
	;; invert side of playing field and account for Riley's height
	move.w	#11,d2

DetermineRileySpriteTopBottomSolid:
	;; use riley sprite x position
	;; subtract platform offset (stored in truck sprite)
	sub.w	8(a5),d1
	;; find the tile we are on
	lsr.w	#3,d1
	;; invert side of playing field and account for Riley's height
	;; already in d2
	sub.w	d1,d2
	move.w	d2,d1

	;; get riley sprite x position
	move.w	d0,d2
	;; subtract level offset (stored in truck sprite)
	sub.w	14(a5),d2
	;; store tile offset in d3
	move.w	d2,d3
	andi.w	#$0007,d3
	;; find the tile we are on
	asr.w	#3,d2
	;; invert side of playing field to match platform data and Riley's width
	move.w	#40,d0
	sub.w	d2,d0

	;; need to multipy by 2 since word entries
	lsl.w	#1,d0

	move.w	PlatformOffsetTiles(a0,d0.w),d2
	btst	d1,d2
	bne.s	DetermineRileySpriteBottomSolidDone

	move.w	PlatformOffsetTilesMinus2(a0,d0.w),d2
	btst	d1,d2
	bne.s	DetermineRileySpriteBottomSolidDone

	;; if offset in tile, need to check a third tile
	tst	d3
	beq.s	DetermineRileySpriteBottomSolidDone
	
	move.w	PlatformOffsetTilesMinus4(a0,d0.w),d2
	btst	d1,d2

DetermineRileySpriteBottomSolidDone:
	movem.w	(a7)+,d0-d3
	rts


	;; a0.l level data
	;; a5.l sprites for player
	;; d0.w is new riley x spot
	;; d1.w is new riley y spot
DetermineRileySpriteLeftSolid:	
	movem.w	d0-d3,-(a7)
	;; invert side of playing field to match platform data and Riley's width
	move.w	#40,d2
	bra.s	DetermineRileySpriteLeftRightSolid

	;; a0.l level data
	;; a5.l sprites for player
	;; d0.w is new riley x spot
	;; d1.w is new riley y spot
DetermineRileySpriteRightSolid:	
	movem.w	d0-d3,-(a7)
	;; invert side of playing field to match platform data and Riley's width
	move.w	#38,d2
DetermineRileySpriteLeftRightSolid:
	;; subtract level offset (stored in truck sprite)
	sub.w	14(a5),d0
	;; find the tile we are on
	asr.w	#3,d0
	;; invert side of playing field to match platform data and Riley's width
	;; already put in d2
	sub.w	d0,d2
	move.w	d2,d0

	;; get riley sprite y position
	move.w	d1,d2
	;; subtract platform offset (stored in truck sprite)
	sub.w	8(a5),d2
	;; store tile offset in d3
	move.w	d2,d3
	andi.w	#$0007,d3
	;; find the tile we are on
	lsr.w	#3,d2
	;; invert side of playing field and account for Riley's height
	move.w	#14,d1
	sub.w	d2,d1

	;; need to multipy by 2 since word entries
	lsl.w	#1,d0

	move.w	PlatformOffsetTiles(a0,d0.w),d2
	btst	d1,d2
	bne.s	DetermineRileySpriteLeftRightSolidDone

	subq.w	#1,d1
	btst	d1,d2
	bne.s	DetermineRileySpriteLeftRightSolidDone

	subq.w	#1,d1
	btst	d1,d2
	bne.s	DetermineRileySpriteLeftRightSolidDone

	;; if offset in tile, need to check a fourth tile
	tst	d3
	beq.s	DetermineRileySpriteLeftRightSolidDone
	
	subq.w	#1,d1
	btst	d1,d2

DetermineRileySpriteLeftRightSolidDone:
	movem.w	(a7)+,d0-d3
	rts

	;; updates letters, and for level 1 the letter x and y positions
	;; no inputs
	;; destroys a5,a6
Level4RefreshLetters:	
	bsr	RefreshLetters

	movem.w d0-d2,-(a7)
	;; update letter x location
	lea	StartWordX,a5
	lea	StartWordX,a6

	clr.w	d0

	move.b	WordIndex,d0

	clr.w	d1
	clr.w	d2
	move.b	(a5,d0.w),d1
	and.b   PlatformOffsetLetterXRange(a0),d1
	move.b	PlatformOffsetLetterX(a0),d2
	add.w	TruckLeftSprite+6,d2
	add.w	d1,d2
	move.w	d2,LetterSprite+6

	clr.w	d1
	clr.w	d2
	move.b	(a6,d0.w),d1
	and.b   PlatformOffsetLetterYRange(a0),d1
	move.b	PlatformOffsetLetterY(a0),d2
	add.w	TruckLeftSprite,d2
	add.w	d1,d2
	move.w	d2,LetterSprite
	
	btst	#TwoPlayerFlag,Flags
	beq.s	Level4RefreshLettersDone

	;; second player letter
	move.b	WordIndex2,d0

	clr.w	d1
	clr.w	d2
	move.b	(a5,d0.w),d1
	and.b   PlatformOffsetLetterXRange(a0),d1
	move.b	PlatformOffsetLetterX(a0),d2
	add.w	Truck2LeftSprite+6,d2
	add.w	d1,d2
	move.w	d2,Letter2Sprite+6

	clr.w	d1
	clr.w	d2
	move.b	(a6,d0.w),d1
	and.b 	PlatformOffsetLetterYRange(a0),d1
	move.b	PlatformOffsetLetterY(a0),d2
	add.w	Truck2LeftSprite,d2
	add.w	d1,d2
	move.w	d2,Letter2Sprite
	
Level4RefreshLettersDone:
	movem.w (a7)+,d0-d2
	rts


	;; a0 has level data pointer
	;; a5 has player sprite pointer
	;; d3[8-15] has the upper byte for the tiles
	;; d7 has vdp address
	;; destroys d0.w, d1.w, d3.b, d7.l
LoadPlatformData:	
	;; update Riley x srite position
	clr.w	d0
	move.b	PlatformOffsetRileyX(a0),d0
	lsl	#3,d0
	add.w	14(a5),d0
	move.w	d0,6(a5)
	;; update Riley y srite position
	clr.w	d0
	move.b	PlatformOffsetRileyY(a0),d0
	lsl	#3,d0
	add.w	8(a5),d0
	move.w	d0,(a5)
	;; update bin x srite position
	clr.w	d0
	move.b	PlatformOffsetBinX(a0),d0
	lsl	#3,d0
	add.w	14(a5),d0
	move.w	d0,30(a5)
	;; update bin x srite position
	clr.w	d0
	move.b	PlatformOffsetBinY(a0),d0
	lsl	#3,d0
	add.w	8(a5),d0
	move.w	d0,24(a5)
	;; now display tiles
	;; number of rows minus 1
	move.w	#13,d1
DisplayPlatformLevelOuterLoop:	
	;; number of cols minus 1
	move.w	#39,d0
	move.l	d7,(a4)
DisplayPlatformLevelInnerLoop:	
	bsr.s	DeterminePlatformLevelTile
	move.w	d3,(a3)
	dbf	d0,DisplayPlatformLevelInnerLoop
	addi.l	#$00800000,d7
	dbf	d1,DisplayPlatformLevelOuterLoop
	rts

;; 	;; a0.l has start of platform level data
;; 	;; d0.w has x (0-39)
;; 	;; d1.w has y (0-27)
;; 	;; z flag is 1 when solid, 0 when clear
;; DeterminePlatformLevelSolid:
;; 	movem.w	d0/d2,-(a7)
;; 	;; multiply d1 by 2 since each column data is two bytes (one word)
;; 	lsl.w	#1,d0
;; 	move.w	PlatformOffsetTiles(a0,d0.w),d2
;; 	btst	d1,d2
;; 	movem.w	(a7)+,d0/d2
;; 	rts

	;; a0.l has start of platform level data
	;; d0.w has x (0-39)
	;; d1.w has y (0-27)
	;; return d3.b as tile:
DeterminePlatformLevelTile:	
	movem.w	d0-d2,-(a7)
	move.b	#0,d3
	addq.w	#1,d0
	addq.w	#1,d1
	;; multiply d1 by 2 since each column data is two bytes (one word)
	lsl.w	#1,d0
	move.w	PlatformOffsetTiles(a0,d0.w),d2
	btst	d1,d2
	beq.s	DeterminePlatformLevelTileDone
	;; solid, determine borders
	addq.w	#1,d1
	btst	d1,d2
	beq.s	DeterminePlatformLevelClearUp
	bset	#0,d3
DeterminePlatformLevelClearUp:	
	subq.w	#2,d1
	btst	d1,d2
	beq.s	DeterminePlatformLevelClearDown
	bset	#1,d3
DeterminePlatformLevelClearDown:
	addq.w	#2,d0
	addq.w	#1,d1
	move.w	PlatformOffsetTiles(a0,d0.w),d2
	btst	d1,d2
	beq.s	DeterminePlatformLevelClearLeft
	bset	#2,d3
DeterminePlatformLevelClearLeft:	
	subq.w	#4,d0
	move.w	PlatformOffsetTiles(a0,d0.w),d2
	btst	d1,d2
	beq.s	DeterminePlatformLevelClearRight
	bset	#3,d3
DeterminePlatformLevelClearRight:	
	addi.b	#($80+(StartBORDER2Tiles-StartTiles)/32),d3	
	
DeterminePlatformLevelTileDone:
	movem.w	(a7)+,d0-d2
	rts

;;; data used for level 4


StartSpriteLevel4Initial:
RileySpriteLevel4Initial:
	dc.b $01,$1D,$06,$03,$C0,$98,$00,$E2
	;; holds upper left position
	dc.b $00,$F0,$00,$00,$00,$00,$00,$80
	dc.b $00,$00,$00,$00,$00,$00,$00,$00
BinSpriteLevel4Initial:
	dc.b $01,$48,$09,$04,$00,$9E,$01,$14
LetterSpriteLevel4Initial:
	dc.b $01,$04,$00,$00,$00,$41,$01,$C0
EndSpriteLevel4Initial:	

StartSpriteLevel4TwoPlayerInitial:
RileySpriteLevel4TwoPlayerInitial:
	dc.b $00,$AD,$06,$05,$C0,$98,$00,$E2
	;; holds upper left position
	dc.b $00,$80,$00,$00,$00,$00,$00,$80
	dc.b $00,$00,$00,$00,$00,$00,$00,$00
BinSpriteLevel4TwoPlayerInitial:
	dc.b $01,$48,$09,$04,$00,$9E,$01,$14
LetterSpriteLevel4TwoPlayerInitial:
	dc.b $00,$94,$00,$08,$00,$41,$01,$C0
Riley2SpriteLevel4TwoPlayerInitial:
	dc.b $01,$1D,$06,$03,$E0,$98,$00,$E2
	;; holds upper left position
	dc.b $00,$F0,$00,$00,$00,$00,$00,$80
	dc.b $00,$00,$00,$00,$00,$00,$00,$00
Bin2SpriteLevel4TwoPlayerInitial:
	dc.b $01,$48,$09,$09,$28,$9E,$01,$64
Letter2SpriteLevel4TwoPlayerInitial:
	dc.b $01,$04,$00,$00,$20,$41,$01,$C0
EndSpriteLevel4TwoPlayerInitial:	

	include LEVEL4D.ASM
	include LEVEL5D.ASM
	include LEVEL6D.ASM
	include LEVEL7D.ASM
	include LEVEL8D.ASM
	